package com.tbit.uqbike.client.service.impl;

import com.tbit.uqbike.client.pojo.Result;
import com.tbit.uqbike.client.constant.StudyGuideConstant;
import com.tbit.uqbike.client.dao.core.UserStudyGuideMapper;
import com.tbit.uqbike.client.pojo.RideLog;
import com.tbit.uqbike.client.pojo.UserStudyGuide;
import com.tbit.uqbike.client.pojo.newEntity.AccountConfigExt;
import com.tbit.uqbike.client.service.CacheService;
import com.tbit.uqbike.client.service.RideLogService;
import com.tbit.uqbike.client.service.StudyGuideService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.util.*;
import java.util.stream.Collectors;


/**
 * <p>
 * 新用户指南 服务实现类
 * </p>
 *
 * @author zhangtianyou
 * @since 2024-11-14
 */
@Service
public class StudyGuideServiceImpl implements StudyGuideService {

    @Autowired
    private RideLogService rideLogService;
    @Autowired
    private UserStudyGuideMapper userStudyGuideMapper;
    @Autowired
    CacheService cacheService;

    @Override
    public Result<Map<String, Object>> checkUserIsStudy(Integer accountId, Integer userId) {

        List<AccountConfigExt> accountConfigExtList = cacheService.getAccountConfigExt(accountId);

        HashMap<String, Object> notShowResultMap = new HashMap<>();
        notShowResultMap.put("isShow", false);

        //判断是否开启新用户引导
        if (!isEnableAccountConfig(accountConfigExtList)) {
            return Result.success(notShowResultMap);
        }

        Map<String, String> extMap = accountConfigExtList.stream()
                .collect(Collectors.toMap(
                        AccountConfigExt::getParamKey,
                        AccountConfigExt::getParamValue
                ));
        HashMap<String, Object> showResultMap = new HashMap<>();
        showResultMap.put("isShow", true);
        showResultMap.put("isSkip", StudyGuideConstant.SKIP_SWITCH_OPEN.equals(extMap.get(StudyGuideConstant.NEW_USER_SKIPPAGE)));
        String pageStr = extMap.get(StudyGuideConstant.NEW_USER_PAGE);
        String[] pageArr = pageStr.split(",");
        showResultMap.put("pageList", pageArr);

        //判断是否符合生效人群
        if (!isEffectiveGroup(extMap, userId)) {
            return Result.success(notShowResultMap);
        }
        //判断当前用户借车次数是否上限
        if (isEffectiveCount(extMap, accountId, userId)) {
            return Result.success(notShowResultMap);
        }

        //生效模式为每次借车
        if (StudyGuideConstant.NEW_USER_EFFECTTIMES_EVERY.equals(extMap.get(StudyGuideConstant.NEW_USER_EFFECTTIMES))) {
            updateUserStudyCount(accountId, userId);
            return Result.success(showResultMap);
        }
        //生效模式为每天首次借车
        if (StudyGuideConstant.NEW_USER_EFFECTTIMES_ONCE_A_DAY.equals(extMap.get(StudyGuideConstant.NEW_USER_EFFECTTIMES))) {
            UserStudyGuide userStudyGuide = userStudyGuideMapper.getUserStudyGuideByUserId(accountId, userId);
            if (userStudyGuide == null) {
                updateUserStudyCount(accountId, userId);
                return Result.success(showResultMap);
            }
            //判断今天是否弹出过
            if (!isToday(userStudyGuide.getUpdateTime())) {
                updateUserStudyCount(accountId, userId);
                return Result.success(showResultMap);
            }
        }
        return Result.success(notShowResultMap);
    }

    /**
     * 判断今天是否弹出过
     *
     * @return true 今天弹出过，false 今天未弹出过
     */
    private boolean isToday(Date updateTime) {
        // 获取当前日期的 Calendar 实例
        Calendar calendar = Calendar.getInstance();

        // 清空时间部分，只保留年、月、日
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);

        // 获取今天的起始时间（午夜 00:00:00）
        Date todayStart = calendar.getTime();

        // 获取今天的结束时间（次日午夜 00:00:00 的前一秒，即今天的 23:59:59.999）
        calendar.add(Calendar.DAY_OF_YEAR, 1);
        Date todayEnd = calendar.getTime();
        calendar.add(Calendar.DAY_OF_YEAR, -1); // 回滚到原始状态，以免影响其他调用

        // 判断 updateTime 是否在今天的时间范围内
        return updateTime.compareTo(todayStart) >= 0 && updateTime.compareTo(todayEnd) < 0;
    }

    /**
     * 判断当前用户借车次数是否上限
     *
     * @param extMap    配置参数
     * @param userId    用户id
     * @param accountId 区域id
     *                  return true 上限，false 未上限
     */
    private boolean isEffectiveCount(Map<String, String> extMap, Integer accountId, Integer userId) {
        int effectiveCount = Integer.parseInt(extMap.get(StudyGuideConstant.NEW_USER_COUNT));
        UserStudyGuide userStudyGuide = userStudyGuideMapper.getUserStudyGuideByUserId(accountId, userId);
        Integer currentCount = userStudyGuide == null ? 0 : userStudyGuide.getCount();
        if (currentCount >= effectiveCount && effectiveCount != 0) {
            return true;
        }
        return false;
    }

    /**
     * 判断是否符合生效人群
     *
     * @param extMap 配置参数
     * @param userId 用户id
     * @return true 符合，false 不符合
     */
    private boolean isEffectiveGroup(Map<String, String> extMap, Integer userId) {
        //生效人群为老用户并且该用户为新用户不显示引导
        RideLog lastByUserId = rideLogService.getLastByUserId(userId);
        if (lastByUserId == null && StudyGuideConstant.NEW_USER_EFFECTPEOPLE_OLD.equals(extMap.get(StudyGuideConstant.NEW_USER_EFFECTPEOPLE))) {
            return false;
        }
        //生效人群为新用户并且该用户为老用户不显示引导
        if (lastByUserId != null && StudyGuideConstant.NEW_USER_EFFECTPEOPLE_NEW.equals(extMap.get(StudyGuideConstant.NEW_USER_EFFECTPEOPLE))) {
            return false;
        }
        return true;
    }

    /**
     * 判断是否开启配置，默认是不开启
     *
     * @param accountConfigExtList 配置列表
     * @return true 开启，false 未开启
     */
    private boolean isEnableAccountConfig(List<AccountConfigExt> accountConfigExtList) {
        //该区域是否有配置
        if (CollectionUtils.isEmpty(accountConfigExtList)) {
            return false;
        }
        Map<String, String> extMap = accountConfigExtList.stream()
                .collect(Collectors.toMap(
                        AccountConfigExt::getParamKey,
                        AccountConfigExt::getParamValue
                ));
        //该区域是否初始化新用户指南配置，是否开启新用户引导
        if (StringUtils.isEmpty(extMap.get(StudyGuideConstant.NEW_USER_SWITCH)) ||
                StudyGuideConstant.NEW_USER_SWITCH_CLOSE.equals(extMap.get(StudyGuideConstant.NEW_USER_SWITCH))) {
            return false;
        }
        return true;
    }

    /**
     * 更新用户学习新用户指南记录，如果没有则添加
     *
     * @param accountId 区域id
     * @param userId    用户id
     */
    public void updateUserStudyCount(Integer accountId, Integer userId) {
        UserStudyGuide userStudyGuide = userStudyGuideMapper.getUserStudyGuideByUserId(accountId, userId);
        if (userStudyGuide == null) {
            userStudyGuide = new UserStudyGuide();
            userStudyGuide.setAccountId(accountId);
            userStudyGuide.setUserId(userId);
            userStudyGuide.setCount(1);
            userStudyGuide.setCreateTime(new Date());
            userStudyGuide.setUpdateTime(new Date());
            userStudyGuideMapper.insert(userStudyGuide);
        } else {
            UserStudyGuide userStudyGuideUpdate = new UserStudyGuide();
            userStudyGuideUpdate.setUserId(userId);
            userStudyGuideUpdate.setCount(userStudyGuide.getCount() + 1);
            userStudyGuideUpdate.setUpdateTime(new Date());
            userStudyGuideMapper.updateById(userStudyGuideUpdate);
        }
    }
}
